//const tf = require('@tensorflow/tfjs-node');  // 如果安装的是CPU版本,必须放在文件的最顶部
const express = require('express');
const bodyParser = require('body-parser');
const cors = require('cors');
const mysql = require('mysql2/promise');
const { dbConfig } = require('./sqlsetting');
const axios = require('axios');

const AipFaceClient = require("baidu-aip-sdk").face;

// 设置APPID/AK/SK
const APP_ID = '118146470';
const API_KEY = '2tmP42B6ARNuf5gtsOSbX0ZA';
const SECRET_KEY = '7qJTxfi7nx5oGJenZQiZ8xXVY4zTNcqv';

// 初始化AipFaceClient
const client = new AipFaceClient(APP_ID, API_KEY, SECRET_KEY);
//需要GPU加速，二选其一
// 如果你安装的是 @tensorflow/tfjs-node
//没有GPU或者不想用GPU，则用CPU加速，执行 npm install @tensorflow/tfjs-node
//require('@tensorflow/tfjs-node');   //没有GPU或者不想用GPU，则用CPU加速

// 如果你安装的是 @tensorflow/tfjs-node-gpu
//有 NVIDIA GPU 并且安装了 CUDA 和 cuDNN，执行 npm install @tensorflow/tfjs-node-gpu
//require('@tensorflow/tfjs-node-gpu');

// 在 index.js 顶部添加
//因为我实在没装上Visual Studio 这个没搞好，还有不知道啥，于是选择使用纯JavaScript模式
//（备用方案，无tensorflow.js绑定本地）
//const tf = require('@tensorflow/tfjs');    //不绑定本地，其他两个会报错，中间应该出现过，cpu可以的，但我以为错了
//const tf = require('@tensorflow/tfjs-node');  // 如果安装的是CPU版本

//const faceapi = require('face-api.js');
//const path = require('path'); // 引入 path 模块

// 创建 Express 应用
const app = express();
const port = 8000;

// 使用 body-parser 中间件解析 JSON 数据
app.use(bodyParser.json({ limit: '10mb' })); // 增加请求体大小限制为 10MB
app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));

// 使用 cors 中间件解决跨域问题
app.use(cors({
  origin: 'http://localhost:8088', // 允许的前端地址
  methods: ['GET', 'POST', 'PUT', 'DELETE'], // 允许的请求方法
  credentials: true // 允许携带凭证（如 cookies）
}));

// 定义模型文件的相对路径
//const modelsPath = path.join(__dirname, '../models');

//// 加载模型
//faceapi.nets.ssdMobilenetv1.loadFromDisk(modelsPath);
//faceapi.nets.faceLandmark68Net.loadFromDisk(modelsPath);
//faceapi.nets.faceRecognitionNet.loadFromDisk(modelsPath);


// 登录接口
// 登录接口
app.post('/api/login', async (req, res) => {
    const { username, password } = req.body;
    console.log(username, password);
    try {
        // 建立数据库连接
        const connection = await mysql.createConnection(dbConfig);
        console.log('成功连接到 MySQL 数据库');

        // 查询数据库中是否存在匹配的账号和密码
        const [rows] = await connection.execute('SELECT * FROM user WHERE account = ? AND password = ?', [username, password]);

        if (rows.length > 0) {
            // 关闭数据库连接
            console.log('rows[0].role的值为:', rows[0].role);
            await connection.end();
            console.log('MySQL 数据库连接已关闭');

            // 如果查询到结果，说明账号和密码匹配，登录成功
            res.json({
                message: '登录成功',rows: rows
            });
        } else {
            // 关闭数据库连接
            await connection.end();
            console.log('MySQL 数据库连接已关闭');
            // 如果没有查询到结果，说明账号或密码错误，登录失败
            res.status(401).json({ error: '账号或密码错误' });
        }
    } catch (error) {
        console.error('登录时出错:', error);
        res.status(500).json({ error: '登录失败，请稍后再试' });
    }
});

// 新的账号注册接口
// 新的账号注册接口
app.post('/api/register', async (req, res) => {
    const { username, password, role, ...nurseData } = req.body;
    console.log('收到注册请求:', req.body);

    try {
        const connection = await mysql.createConnection(dbConfig);
        console.log('注册功能连接数据库成功');

        // 检查账号是否重复
        const [checkRows] = await connection.execute('SELECT * FROM user WHERE account = ?', [username]);

        if (checkRows.length > 0) {
            await connection.end();
            console.log('MySQL 数据库连接已关闭');
            res.status(200).json({ error: '该账号已存在', exist: true });
        } else {
            // 处理可能为 undefined 的值，将其转换为 null
            const userValues = [
                username !== undefined ? username : null,
                password !== undefined ? password : null,
                role !== undefined ? role : null
            ];

            // 插入用户
            const insertUserQuery = 'INSERT INTO user (account, password, role) VALUES (?, ?, ?)';
            const [userResult] = await connection.execute(insertUserQuery, userValues);
            const userId = userResult.insertId;
            console.log('用户插入成功，用户ID:', userId);

            if (role === 'nurse') {
                // 处理陪护师信息可能为 undefined 的值，将其转换为 null
                const { phone, gender, age, serviceYears, biography } = nurseData;
                const caregiverValues = [
                    username !== undefined ? username : null,
                    phone !== undefined ? phone : null,
                    gender !== undefined ? gender : null,
                    age !== undefined ? age : null,
                    serviceYears !== undefined ? serviceYears : null,
                    biography !== undefined ? biography : null
                ];

                // 插入陪护师信息
                const insertCaregiverQuery = 'INSERT INTO caregiverinformation (name, phone, gender, age, serviceyears, biography) VALUES (?, ?, ?, ?, ?, ?)';
                try {
                    const [caregiverResult] = await connection.execute(insertCaregiverQuery, caregiverValues);
                    const caregiverId = caregiverResult.insertId;
                    console.log('陪护师信息插入成功，陪护师ID:', caregiverId);

                    // 更新 user 表中的 associatedcaregiver
                    const updateUserQuery = 'UPDATE user SET associatedcaregiver = ? WHERE userid = ?';
                    await connection.execute(updateUserQuery, [caregiverId, userId]);
                    console.log('用户表更新成功');
                } catch (caregiverError) {
                    console.error('插入陪护师信息时出错:', caregiverError);
                    await connection.end();
                    console.log('MySQL 数据库连接已关闭');
                    res.status(500).json({ error: '插入陪护师信息失败，请稍后再试' });
                    return;
                }
            } else if (role === 'user') {
                // 处理患者信息可能为 undefined 的值，将其转换为 null
                const { phone } = req.body;
                const patientValues = [
                    username !== undefined ? username : null,
                    phone !== undefined ? phone : null
                ];

                // 插入患者信息，将 username 插入 name 列
                const insertPatientQuery = 'INSERT INTO patientinformation (name, phone) VALUES (?, ?)';
                const [patientResult] = await connection.execute(insertPatientQuery, patientValues);
                const patientId = patientResult.insertId;
                console.log('患者信息插入成功，患者ID:', patientId);

                // 更新 user 表中的 linkuserid
                const updateUserQuery = 'UPDATE user SET linkuserid = ? WHERE userid = ?';
                await connection.execute(updateUserQuery, [patientId, userId]);
                console.log('用户表更新成功');
            }

            await connection.end();
            console.log('MySQL 数据库连接已关闭');
            res.status(200).json({ message: '注册成功', exist: false, userId: userId, role: role });
        }
    } catch (error) {
        console.error('注册时出错:', error);
        res.status(500).json({ error: '注册失败，请稍后再试' });
    }
});

// 新增人脸采集专用接口
app.post('/api/face-collection', async (req, res) => {
  let connection;
  try {
    const { username, password, role, image } = req.body;

    // 参数校验
    if (!username || !password || !role || !image) {
      return res.status(400).json({ error: '缺少必要参数' });
    }

    // 验证用户身份
    connection = await mysql.createConnection(dbConfig);
    const [rows] = await connection.execute(
      'SELECT userid FROM user WHERE account = ? AND password = ? AND role = ?',
      [username, password, role]
    );

    if (rows.length === 0) {
      return res.status(401).json({ error: '身份验证失败' });
    }

    const userid = rows[0].userid;

    // 获取百度云access_token
    const access_token = await axios.post(
      `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${API_KEY}&client_secret=${SECRET_KEY}`
    ).then(res => res.data.access_token);

    // 调用百度云API
    const baiduResponse = await axios.post(
      'https://aip.baidubce.com/rest/2.0/face/v3/faceset/user/add',
      {
        user_id: userid.toString(),
        image: image.split(',')[1], // 去除base64前缀
        image_type: 'BASE64',
        group_id: 'dz_321'
      },
      { params: { access_token } }
    );

    // 处理百度云响应
    if (baiduResponse.data.error_code === 0) {
      // 更新数据库
      await connection.execute(
        'UPDATE user SET baidu_face_user_id = ? WHERE userid = ?',
        [userid, userid]
      );
      res.json({ success: true });
    } else {
      res.status(400).json({
        error: `百度云错误: ${baiduResponse.data.error_msg}`,
        code: baiduResponse.data.error_code
      });
    }
  } catch (error) {
    console.error('人脸采集失败:', error);
    res.status(500).json({
      error: '服务器内部错误',
      detail: error.message
    });
  } finally {
    if (connection) await connection.end();
  }
});

//性能优化
// 在后端添加缓存机制
const accessTokenCache = {
  token: null,
  expires: 0
};

// 修改获取access_token方法
async function getBaiduAccessToken() {
  if (Date.now() < accessTokenCache.expires) {
    return accessTokenCache.token;
  }

  const response = await axios.post(
    `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${API_KEY}&client_secret=${SECRET_KEY}`
  );

  accessTokenCache.token = response.data.access_token;
  accessTokenCache.expires = Date.now() + (response.data.expires_in - 300) * 1000; // 提前5分钟刷新

  return accessTokenCache.token;
}

// 完善人脸登录接口
// 完善人脸登录接口
app.post('/api/login-face', async (req, res) => {
  const { image, role } = req.body;

  try {
    // 参数校验
    if (!image || !role) {
      return res.status(400).json({ error: '缺少必要参数' });
    }

    // 处理Base64数据
    const base64Data = image.includes('base64,') ?
      image.split(',')[1] :
      image;

    // 调用百度云接口
    const result = await client.search(base64Data, 'BASE64', 'dz_321', {
      quality_control: "NORMAL",
      liveness_control: "LOW",
      max_user_num: 1
    });

    // 处理百度云响应
    if (result.error_code === 0 && result.result.user_list[0].score > 30) {
      const baiduUserId = result.result.user_list[0].user_id;

      // 查询数据库
      const connection = await mysql.createConnection(dbConfig);
      const [rows] = await connection.execute(
        'SELECT * FROM user WHERE baidu_face_user_id = ? AND role = ?',
        [baiduUserId, role]
      );

      if (rows.length > 0) {
        // 直接返回登录成功信息
        res.json({
          success: true,
          userid: rows[0].userid,
          username: rows[0].account,
          role: rows[0].role
        });
      } else {
        res.status(404).json({ error: '用户未注册或身份不匹配' });
      }
    } else {
      res.status(401).json({
        error: '人脸验证失败',
        detail: result.error_msg || '识别分数不足'
      });
    }
  } catch (error) {
    console.error('人脸登录失败:', error);
    res.status(500).json({ error: '服务器错误' });
  }
});


// 新增陪诊师信息接口
app.post('/addCaregiver', async (req, res) => {
    const { name, money, phone, gender, age, jobnumber, address, serviceyears, biography, status, avater, isok } = req.body;
    console.log(req.body, '22222');

    // 处理可能为 undefined 的值，将其转换为 null
    const values = [
        name !== undefined ? name : null,
        money !== undefined ? money : null,
        phone !== undefined ? phone : null,
        gender !== undefined ? gender : null,
        age !== undefined ? age : null,
        jobnumber !== undefined ? jobnumber : null,
        address !== undefined ? address : null,
        serviceyears !== undefined ? serviceyears : null,
        biography !== undefined ? biography : null,
        status !== undefined ? status : null,
        avater !== undefined ? avater : null,
        isok !== undefined ? isok : null
    ];
    console.log(values, '22222');
    try {
        // 建立数据库连接
        const connection = await mysql.createConnection(dbConfig);
        console.log('成功连接到 MySQL 数据库');

        // 插入新陪护师信息
        const insertQuery = 'INSERT INTO caregiverinformation (name, money, phone, gender, age, jobnumber, address, serviceyears, biography, status, avater, isok) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)';
        await connection.execute(insertQuery, values);

        await connection.end();
        console.log('MySQL 数据库连接已关闭');
        res.status(200).json({ message: '陪护师信息添加成功' });
    } catch (error) {
        console.error('添加陪诊师信息时出错:', error);
        res.status(500).json({ error: '添加陪护师信息失败，请稍后再试' });
    }
});

// 修改陪诊师信息接口
app.post('/api/updateCaregiver', async (req, res) => {
  const { caregiverid, name, money, phone, gender, age, jobnumber, address, serviceyears, biography, status, avater, isok } = req.body;
  console.log('收到更新陪护师信息的请求:', req.body);

  // 处理可能为 undefined 的值，将其转换为 null
  const values = [
    name !== undefined ? name : null,
    money !== undefined ? money : null,
    phone !== undefined ? phone : null,
    gender !== undefined ? gender : null,
    age !== undefined ? age : null,
    jobnumber !== undefined ? jobnumber : null, // 新增工号字段
    address !== undefined ? address : null,
    serviceyears !== undefined ? serviceyears : null,
    biography !== undefined ? biography : null,
    status !== undefined ? status : null,
    avater !== undefined ? avater : null,
    isok !== undefined ? isok : null,
    caregiverid
  ];

  try {
    // 建立数据库连接
    const connection = await mysql.createConnection(dbConfig);
    console.log('成功连接到 MySQL 数据库');

    // 构建更新陪护师信息的 SQL 查询语句，移除注释
    const updateQuery = `
      UPDATE caregiverinformation
      SET
        name = ?,
        money = ?,
        phone = ?,
        gender = ?,
        age = ?,
        jobnumber = ?,
        address = ?,
        serviceyears = ?,
        biography = ?,
        status = ?,
        avater = ?,
        isok = ?
      WHERE caregiverid = ?
    `;

    // 执行更新操作
    const [result] = await connection.execute(updateQuery, values);

    if (result.affectedRows === 0) {
      // 如果没有记录被更新，可能是 caregiverid 不存在
      await connection.end();
      console.log('MySQL 数据库连接已关闭');
      res.status(404).json({ error: '未找到对应的陪护师信息' });
    } else {
      // 陪护师信息更新成功
      await connection.end();
      console.log('MySQL 数据库连接已关闭');
      res.status(200).json({ message: '陪护师信息更新成功' });
    }
  } catch (error) {
    console.error('修改陪护师信息时出错:', error);
    res.status(500).json({ error: '修改陪护师信息失败，请稍后再试' });
  }
});


// 根据 caregiverid 查询陪诊师信息接口
app.get('/api/getCaregiverById', async (req, res) => {
  const caregiverid = req.query.caregiverid;

  if (!caregiverid) {
    return res.status(400).json({ error: '缺少 caregiverid 参数' });
  }

  try {
    const connection = await mysql.createConnection(dbConfig);
    console.log('根据ID筛选陪诊师成功连接到 MySQL 数据库');

    const selectQuery = `
      SELECT *
      FROM caregiverinformation
      WHERE caregiverid = ?
    `;

    const [rows] = await connection.execute(selectQuery, [caregiverid]);

    if (rows.length === 0) {
      res.status(404).json({ error: '未找到对应ID的陪护师信息' });
    } else {
      console.log('已经找到对应ID陪诊师信息');
      res.status(200).json(rows[0]);
    }
  } catch (error) {
    console.error('查询陪护师信息时出错:', error);
    res.status(500).json({ error: '查询陪诊师ID失败，请稍后再试' });
  }
});



// 查询所有陪诊师信息接口
app.get('/api/getAllCaregivers', async (req, res) => {
    try {
        // 建立数据库连接
        const connection = await mysql.createConnection(dbConfig);
        console.log('查询全部陪诊师成功连接到 MySQL 数据库');

        // 构建查询所有陪护师信息的 SQL 查询语句
        const selectQuery = 'SELECT * FROM caregiverinformation';

        // 执行查询操作
        const [rows] = await connection.execute(selectQuery);

        if (rows.length === 0) {
            // 如果没有查询到记录，说明表中没有陪护师信息
            //await connection.end();
            //console.log('MySQL 数据库连接已关闭');
            res.status(404).json({ error: '查询所有时未找到任何陪护师信息' });
        } else {
            // 找到陪护师信息，将结果数组返回给前端
            //await connection.end();
            //console.log('MySQL 数据库连接已关闭');
            console.log('已查询所有陪诊师信息');
            res.status(200).json(rows);
        }
    } catch (error) {
        console.error('查询所有陪诊师信息时出错:', error);
        res.status(500).json({ error: '查询所有陪诊师信息失败，请稍后再试' });
    }
});

// 修改筛选接口支持部分参数,筛选陪诊师接口
app.get('/api/getFilteredCaregivers', async (req, res) => {
    const { money, gender, age, address, serviceyears } = req.query; // 参数名与前端保持一致

    try {
        const connection = await mysql.createConnection(dbConfig);
        console.log('根据选择挑战筛选陪诊师成功连接到 MySQL 数据库');
        let baseQuery = 'SELECT * FROM caregiverinformation WHERE 1=1';
        const params = [];

        // 价格筛选（示例：前端传参"100-150"）
        if (money) {
            const [min, max] = money.split('-').map(Number);
            baseQuery += ' AND money BETWEEN ? AND ?';
            params.push(min, max);
        }

        // 性别筛选（示例：传参"男"）
        if (gender) {
            baseQuery += ' AND gender = ?';
            params.push(gender);
        }

        // 年龄筛选（示例：传参"25-35"）
        if (age) {
            const [minAge, maxAge] = age.split('-').map(Number);
            baseQuery += ' AND age BETWEEN ? AND ?';
            params.push(minAge, maxAge);
        }

        // 地区筛选（示例：传参"金水区"）
        if (address) {
            baseQuery += ' AND address = ?';
            params.push(address);
        }

        // 从业年限转换逻辑
        if (serviceyears) {
            switch(serviceyears) {
                case '小于2年':
                    baseQuery += ' AND serviceyears < 2';
                    break;
                case '2-5年':
                    baseQuery += ' AND serviceyears BETWEEN 2 AND 5';
                    break;
                case '5-10年':
                    baseQuery += ' AND serviceyears BETWEEN 5 AND 10';
                    break;
                case '10年以上':
                    baseQuery += ' AND serviceyears >= 10';
                    break;
            }
        }

        console.log('最终执行SQL:', baseQuery, params); // 调试日志

        const [rows] = await connection.execute(baseQuery, params);
        //await connection.end(); // 保持每次查询后关闭连接
        console.log('根据自选筛选条件查询陪诊师信息成功'); // 调试日志

        res.status(200).json(rows);
    } catch (error) {
        console.error('筛选出错:', error);
        res.status(500).json({ error: '筛选失败' });
    }
});





// 新增就诊人信息接口
app.post('/addPatient', async (req, res) => {
    const { name, phone, hospital, department, starttime, time, gender, age, caregiverid } = req.body;
    console.log('接收到的请求体:', req.body); // 打印完整请
    console.log(req.body, '22222');

    // 处理可能为 undefined 的值，将其转换为 null
    const values = [
        name !== undefined ? name : null,
        phone !== undefined ? phone : null,
        hospital !== undefined ? hospital : null,
        department !== undefined ? department : null,
        starttime !== undefined ? starttime : null,
        time !== undefined ? time : null,
        gender !== undefined ? gender : null,
        age !== undefined ? age : null,
        caregiverid !== undefined ? caregiverid : null
    ];
    console.log(values, '22222');
    try {
        // 建立数据库连接
        const connection = await mysql.createConnection(dbConfig);
        console.log('新增就诊人成功连接到 MySQL 数据库');

        // 插入新就诊人信息
        const insertQuery = 'INSERT INTO patientinformation (name, phone, hospital, department, starttime, time, gender, age, caregiverid) VALUES (?,?,?,?,?,?,?,?,?)';
        await connection.execute(insertQuery, values);

        await connection.end();
        console.log('MySQL 数据库连接已关闭');
        res.status(200).json({ message: '就诊人信息添加成功' });
    } catch (error) {
        console.error('添加就诊人信息时出错:', error);
        res.status(500).json({ error: '添加就诊人信息失败，请稍后再试' });
    }
});

// 在后端index.js中添加支付状态检查接口
app.get('/api/check-payment-status', async (req, res) => {
  try {
    const { orderId } = req.query;
    // 实现实际的支付状态验证逻辑（示例）
    const paymentStatus = await checkPaymentInDatabase(orderId);
    res.status(200).json({
      status: paymentStatus ? "paid" : "unpaid",
      orderId
    });
  } catch (error) {
    console.error('支付状态-00检查错误:', error);
    res.status(500).json({ error: '支付状态检查失败' });
  }
});

// 模拟数据库检查函数
async function checkPaymentInDatabase(orderId) {
  // 这里添加实际数据库查询逻辑
  return true; // 示例返回支付成功
}

// 获取预约记录接口
app.get('/api/get-appointment-list', async (req, res) => {
  try {
    const connection = await mysql.createConnection(dbConfig);
    const [rows] = await connection.execute(`
      SELECT * FROM appointments
      WHERE user_id = ?
      ORDER BY create_time DESC
    `, [req.user.id]); // 假设已实现用户认证

    res.status(200).json(rows);
  } catch (error) {
    console.error('获取预约记录失败:', error);
    res.status(500).json({ error: '获取预约记录失败' });
  }
});

// 修改后的查询就诊人信息接口（通过userid查询）
app.get('/api/queryPatientByUserId', async (req, res) => {
  const { userid } = req.query;
  try {
    const connection = await mysql.createConnection(dbConfig);
    // 通过user表找到linkuserid，再查询patientinformation
    const [userRows] = await connection.execute(
      'SELECT linkuserid FROM user WHERE userid = ?',
      [userid]
    );

    if (!userRows[0]?.linkuserid) {
      await connection.end();
      return res.status(404).json({ error: '未找到关联的就诊人信息' });
    }

    const [patientRows] = await connection.execute(
      'SELECT * FROM patientinformation WHERE id = ?',
      [userRows[0].linkuserid]
    );

    await connection.end();
    res.status(200).json(patientRows[0] || {});
  } catch (error) {
    console.error('查询失败:', error);
    res.status(500).json({ error: '查询失败' });
  }
});

// 获取公共订单（caregiverid为null）
// 获取公共订单（caregiverid为null）
// 修改后的获取公共订单接口
// 获取公共订单（caregiverid为null）
app.get('/api/getPublicOrders', async (req, res) => {
  console.log('收到获取公共订单请求:', req.query);
  try {
    const { page = 1, pageSize = 10 } = req.query;
    const offset = (page - 1) * pageSize;

    const connection = await mysql.createConnection(dbConfig);

    // 获取总数
    const [countRows] = await connection.execute(
      'SELECT COUNT(*) AS total FROM patientinformation WHERE caregiverid IS NULL AND hospital IS NOT NULL AND hospital != "" AND department IS NOT NULL AND department != ""'
    );

    // 获取分页数据
    const [rows] = await connection.execute(
      `SELECT *, 200 AS amount FROM patientinformation
       WHERE caregiverid IS NULL AND hospital IS NOT NULL AND hospital != "" AND department IS NOT NULL AND department != ""
       LIMIT ? OFFSET ?`,
      [parseInt(pageSize), offset]
    );

    await connection.end();
    res.status(200).json({
      data: rows,
      total: countRows[0].total
    });

  } catch (error) {
    console.error('获取公共订单失败:', error);
    res.status(500).json({ error: '获取公共订单失败' });
  }
});

// 获取我的订单（根据陪诊师ID）
// 根据陪护师 ID 获取相关就诊人信息接口
// 根据陪护师 ID 获取相关就诊人信息接口
// 根据陪护师 ID 获取相关就诊人信息接口
// 获取指定陪诊师的订单列表接口
app.get('/api/getMyOrders', async (req, res) => {
  const { caregiverId, page = 1, pageSize = 10 } = req.query;
  const offset = (page - 1) * pageSize;

  console.log('接收到的请求参数:', req.query);

  if (!caregiverId) {
    console.log('缺少 caregiverId 参数');
    return res.status(400).json({ error: '缺少 caregiverId 参数' });
  }

  try {
    const connection = await mysql.createConnection(dbConfig);
    console.log('我的订单陪诊师成功连接到 MySQL 数据库');

    // 获取总数
    const [countRows] = await connection.execute(
      'SELECT COUNT(*) AS total FROM patientinformation WHERE caregiverid = ?',
      [caregiverId]
    );

    console.log('总数查询 SQL:', 'SELECT COUNT(*) AS total FROM patientinformation WHERE caregiverid = ?', [caregiverId]);

    // 获取分页数据
    const [rows] = await connection.execute(
      `SELECT * FROM patientinformation
       WHERE caregiverid = ?
       LIMIT ? OFFSET ?`,
      [caregiverId, parseInt(pageSize), offset]
    );

    console.log('分页数据查询 SQL:', `SELECT * FROM patientinformation WHERE caregiverid = ? LIMIT ? OFFSET ?`, [caregiverId, parseInt(pageSize), offset]);

    await connection.end();

    // 确保返回的数据是数组
    res.status(200).json(rows);

  } catch (error) {
    console.error('查询失败:', error);
    res.status(500).json({ error: '查询失败' });
  }
});

app.post('/api/acceptOrder', async (req, res) => {
  console.log('收到接单请求:', req.body); // 添加日志
  const { orderid, caregiverid } = req.body;
  try {
    const connection = await mysql.createConnection(dbConfig);
    await connection.execute(
      'UPDATE patientinformation SET caregiverid = ? WHERE id = ?',
      [caregiverid, orderid]
    );
    await connection.end();
    console.log('接单成功:', { orderid, caregiverid }); // 添加日志
    res.status(200).json({ message: '接单成功' });
  } catch (error) {
    console.error('接单失败:', error); // 添加错误日志
    res.status(500).json({ error: '接单失败，请稍后再试' });
  }
});

// 数据迁移脚本示例
async function migrateUserData() {
  const connection = await mysql.createConnection(dbConfig);
  const [users] = await connection.execute('SELECT userid FROM user');

  for (const user of users) {
    const userid = user.userid;
    // 确保百度云 user_id 唯一
    const baiduFaceUserId = `user_${userid}`;

    await connection.execute(
      'UPDATE user SET baidu_face_user_id = ? WHERE userid = ?',
      [baiduFaceUserId, userid]
    );
  }

  await connection.end();
  console.log('数据迁移完成');
}

migrateUserData().catch(error => {
  console.error('数据迁移出错:', error);
});


// 启动服务器
app.listen(port, () => {
    console.log(`服务器运行在 http://localhost:${port}`);
});